﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ZR.Infrastructure
{
    // 自定义固定长度且线程安全的列表类
    public class SafeList<T>
    {
        private readonly List<T> _list;
        private readonly int _maxSize;
        private readonly object _lockObject = new object();

        // 构造函数，初始化列表和最大长度
        public SafeList(int maxSize = -1)
        {
            _list = new List<T>();
            _maxSize = maxSize;
        }

        // 添加元素的方法
        public void Add(T item)
        {
            lock (_lockObject)
            {
                if (_maxSize > -1 && _list.Count >= _maxSize)
                {
                    // 如果列表已满，移除第一个元素
                    _list.RemoveAt(0);
                }
                _list.Add(item);
            }
        }

        // 清空原有数据并追加新的列表元素
        public void ClearAndAddRange(List<T> items)
        {
            // 验证参数有效性
            if (items == null)
                throw new ArgumentNullException(nameof(items), "传入的列表不能为null");

            lock (_lockObject)
            {
                // 清空原有数据
                _list.Clear();
                // 追加新列表的所有元素
                _list.AddRange(items);

                // 如果设置了最大长度限制，且新元素总数超过限制，移除超出部分
                if (_maxSize > -1 && _list.Count > _maxSize)
                {
                    // 计算需要移除的元素数量（保留后面的元素）
                    int removeCount = _list.Count - _maxSize;
                    _list.RemoveRange(0, removeCount);
                }
            }
        }


        // 获取指定索引的元素
        public T this[int index]
        {
            get
            {
                lock (_lockObject)
                {
                    return _list[index];
                }
            }
        }

        // 获取列表当前的元素数量
        public int Count
        {
            get
            {
                lock (_lockObject)
                {
                    return _list.Count;
                }
            }
        }

        // 清空列表
        public void Clear()
        {
            lock (_lockObject)
            {
                _list.Clear();
            }
        }

        // 将列表元素转换为数组
        public T[] ToArray()
        {
            lock (_lockObject)
            {
                return _list.ToArray();
            }
        }

        // 将列表元素转换为新的 List<T>
        public List<T> ToList()
        {
            lock (_lockObject)
            {
                return new List<T>(_list);
            }
        }

        // 新增：根据Lambda表达式条件移除元素
        // 返回值：被移除的元素数量
        public int Remove(Predicate<T> predicate)
        {
            lock (_lockObject)
            {
                // 记录移除前的数量
                int initialCount = _list.Count;

                // 移除所有符合条件的元素
                _list.RemoveAll(predicate);

                // 返回移除的元素数量
                return initialCount - _list.Count;
            }
        }

        // 新增：移除第一个符合Lambda表达式条件的元素
        // 返回值：是否成功移除元素
        public bool RemoveFirst(Predicate<T> predicate)
        {
            lock (_lockObject)
            {
                int index = _list.FindIndex(predicate);
                if (index != -1)
                {
                    _list.RemoveAt(index);
                    return true;
                }
                return false;
            }
        }
    }
}
